package com.xsoft.web.util;

/**
 * Copyright (C) 2004-2008 Giant Interective Group, Inc. All rights reserved.
 *
 * @(#) StringUtil.java 1.0 2008-09-02
 */


import java.lang.reflect.Type;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.List;
import java.util.Locale;
import java.util.ResourceBundle;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import com.opensymphony.xwork2.LocaleProvider;
import com.opensymphony.xwork2.TextProvider;
import com.opensymphony.xwork2.TextProviderSupport;

/**
 * �ַ���ķ�װ����ࡣ.
 * 
 * @version 1.1.0
 */
public class StringUtil {

    // apache common logging instance
    /** The Constant LOG. */

    /** һ����ַ�ľ�������ʾΪ��&quot;&quot;. */
    public static final String EMPTY = "";

    // HEX CHARS
    /** The Constant HEX_CHARS. */
    private static final char[] HEX_CHARS = { '0', '1', '2', '3', '4', '5',
            '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };

    /** The Constant HIGHEST_SPECIAL. */
    private static final int HIGHEST_SPECIAL = '>';

    /** The special characters representation. */
    private static char[][] specialCharactersRepresentation = new char[HIGHEST_SPECIAL + 1][];
    static {
        specialCharactersRepresentation['&'] = "&amp;".toCharArray();
        specialCharactersRepresentation['<'] = "&lt;".toCharArray();
        specialCharactersRepresentation['>'] = "&gt;".toCharArray();
        specialCharactersRepresentation['"'] = "&#034;".toCharArray();
        specialCharactersRepresentation['\''] = "&#039;".toCharArray();
    }

    /**
     * Ĭ�ϵĹ��췽����.
     */
    StringUtil() {
    }

    /**
     * ���ظ��ַ��UTF8��ʽ�µĳ��ȡ�.
     * 
     * @param str ����ַ�
     * @return ���ַ��UTF8��ʽ�µĳ��ȡ�
     */
    public static Integer utf8Length(String str) {
        if (isNullOrEmpty(str))
            return 0;
        String temp = new String(str);
        return temp.trim().replaceAll("[^\\x00-\\xff]", "***").length();
    }

    /**
     * <p>
     * ����Ķ���Ϊ<code>null</code>�����ַ���ʽΪ"null"���򷵻�<code>true</code>��
     * </p> .
     * 
     * @param o Ҫ��֤�Ķ���
     * @return ����true������Ķ���Ϊ<code>null</code>�����ַ���ʽΪ"<code>null</code>"
     */
    public static boolean isNull(Object o) {
        return o == null;
    }

    /**
     * <p>
     * ����Ķ���Ϊ<code>null</code>�����ַ���ʽΪ���ַ��򷵻�<code>true</code>��
     * </p> .
     * 
     * @param o Ҫ��֤�Ķ���
     * @return ����true������Ķ���Ϊ<code>null</code>�����ַ���ʽΪ���ַ�
     */
    public static boolean isNullOrEmpty(Object o) {
        if (o == null) {
            return true;
        } else if (EMPTY.equals(o.toString().trim())
                || "null".equals(o.toString().trim().toLowerCase())) {
            return true;
        }
        return false;
    }

    /**
     * <p>
     * ���ָ���������ַ���ת��Ϊ<code>java.util.Date</code>���ͣ� �򷵻�<code>true</code>�����򷵻�
     * <code>false</code>��
     * </p>
     * 
     * @param input Ҫ��֤�������ַ�
     * @return ����true�����ָ���������ַ���ת����<code>java.util.Date</code>����
     */
    public static boolean isDate(String input) {
        java.util.Date date = DateUtil.parseDate(input, "yyyy-MM-dd HH:mm:ss");
        return (date != null);
    }

    /**
     * <p>
     * �����ַ���Ա�ʾΪһ��<code>Number</code>���򷵻�<code>true</code>�����򷵻�
     * <code>false</code>��
     * </p> .
     * 
     * @param input ��ʾNumber�ĸ��ַ�
     * @return ����<code>true</code>��������ַ���Ա�ʾΪһ��Number��
     */
    public static boolean isNumber(String input) {
        if (isNullOrEmpty(input))
            return false;
        Object result = null;
        if (input.indexOf('.') > 0) {
            try {
                result = Float.parseFloat(input);
            } catch (NumberFormatException e) {
                return false;
            }
            return (result != null);
        } else {
            try {
                result = Integer.parseInt(input);
            } catch (NumberFormatException e) {
                return false;
            } catch (Exception e) {
                try {
                    result = Long.parseLong(input);
                } catch (Exception ee) {
                    return false;
                }
            }
            return (result != null);
        }
    }

    /**
     * <p>
     * �����ַ�����ȷ��ʽ��Email��ַ���򷵻�<code>true</code>�����򷵻�<code>false</code>��
     * </p> .
     * 
     * @param input ��ʾEmail��ַ�ĸ��ַ�
     * @return ����<code>true</code>��������ַ�����ȷ��ʽ��Email��
     */
    public static boolean isEmail(String input) {
        if (isNullOrEmpty(input))
            return false;
        input = input.trim();
        return Pattern.matches(
                "^(?:\\w+\\.?)*\\w+@(?:\\w+\\.?)*[a-zA-Z]{2,3}$", input);
    }

    /**
     * �Ƴ����ַ��е�<code>(X)HTML</code>��ǩ��.
     * 
     * @param input ����ַ�
     * @return �����Ƴ�<code>(X)HTML</code>��ǩ���ַ�
     */
    public static String stripTags(String input) {
        return input.replaceAll("</?[^>]+>", EMPTY);
    }

    /**
     * ���ַ��е�XML�����ַ�ת���ɿ���ʾ���ַ� �����ַ��ת������ַ�:
     * 
     * <pre>
     *  &amp; --&gt; &amp;amp;
     *  &lt; --&gt; &amp;lt;
     *  &gt; --&gt; &amp;gt;
     *  &quot; --&gt; &amp;#034;
     *  ' --&gt; &amp;#039;
     * </pre> .
     * 
     * @param buffer Ҫ������ַ�
     * @return �������ַ�
     */
    public static String escapeXml(String buffer) {
        int start = 0;
        int length = buffer.length();
        char[] arrayBuffer = buffer.toCharArray();
        StringBuffer escapedBuffer = null;

        for (int i = 0; i < length; i++) {
            char c = arrayBuffer[i];
            if (c <= HIGHEST_SPECIAL) {
                char[] escaped = specialCharactersRepresentation[c];
                if (escaped != null) {
                    // create StringBuffer to hold escaped xml string
                    if (start == 0) {
                        escapedBuffer = new StringBuffer(length + 5);
                    }
                    // add unescaped portion
                    if (start < i) {
                        escapedBuffer.append(arrayBuffer, start, i - start);
                    }
                    start = i + 1;
                    // add escaped xml
                    escapedBuffer.append(escaped);
                }
            }
        }
        // no xml escaping was necessary
        if (start == 0) {
            return buffer;
        }
        // add rest of unescaped portion
        if (start < length) {
            escapedBuffer.append(arrayBuffer, start, length - start);
        }
        return escapedBuffer.toString();
    }

    /**
     * ����Ķ���ת��Ϊ�ַ����.
     * 
     * @param input ��Ҫת���ַ�Ķ���
     * @return ת�����ַ�
     */
    public static String parse(Object input) {
        if (isNullOrEmpty(input))
            return EMPTY;
        return String.valueOf(input);
    }

    /**
     * �����������ת��Ϊ�ַ����.
     * 
     * @param is ���������
     * @return ת�����ַ�
     */
    public static String parse(java.io.InputStream is) {
        StringBuffer buffer = new StringBuffer();
        try {
            byte[] b = new byte[1024];
            int i = 0;
            while ((i = is.read(b)) != -1) {
                buffer.append(new String(b, 0, i));
            }
            is.close();
        } catch (java.io.IOException ioe) {

        }
        return buffer.toString();
    }

    /**
     * ����Ķ���ת����<code>Integer</code>�͡�.
     * 
     * @param input Ҫת��ΪInteger�͵Ķ���
     * @param defaultValue ת�����ʱ���ص�Ĭ��ֵ��
     * @return ת�����Integerֵ��
     */
    public static int parseInt(Object input, int defaultValue) {
        if (isNull(input))
            return defaultValue;
        try {
            return Integer.parseInt(input.toString());
        } catch (NumberFormatException e) {
            return defaultValue;
        }
    }

    /**
     * <p>
     * ʹ��ָ��������ֵ�滻�����滻���ַ�ƥ������ֵĿ�����е�ÿ�����ַ� ���滻�Ӵ��ַ�Ŀ�ʼһֱ���������磬�� "b" �滻�ַ�
     * "aaa" �е� "aa" ����� "ba" ���� "ab"��
     * </p> .
     * 
     * @param input ���Դ�ַ�
     * @param substringBefore Ҫ�滻��Ŀ���ַ�
     * @param substringAfter �����滻Ŀ���ַ�����ַ�
     * @return �滻������ַ�
     */
    public static String replace(String input, String substringBefore,
            String substringAfter) {
        if (input == null)
            input = "";
        if (input.length() == 0)
            return "";
        if (substringBefore == null)
            substringBefore = "";
        if (substringBefore.length() == 0)
            return input;

        StringBuffer buf = new StringBuffer(input.length());
        int startIndex = 0;
        int index;
        while ((index = input.indexOf(substringBefore, startIndex)) != -1) {
            buf.append(input.substring(startIndex, index)).append(
                    substringAfter);
            startIndex = index + substringBefore.length();
        }
        return buf.append(input.substring(startIndex)).toString();
    }

    /**
     * �����ַ���ĳ���ַ���ֵĴ���
     * 
     * @param str �ַ�Դ
     * @param ch ƥ����ַ�
     * @return ���ֵĴ���
     */
    public static int getNum(String str, String ch) {
        int len = ch.length();
        int num = 0;
        for (int i = len; i <= str.length(); i++) {
            String c = str.substring(i - len, i);
            if (c.equals(ch)) {
                num++;
            }
        }
        return num;
    }

    /**
     * ��ȡHtmlƬ�Σ���ȡ��ɾ��ȫ��Html���롣
     * 
     * @param shtml Ҫ��ȡ��HtmlƬ�Ρ�
     * @param iLength Ҫ��ȡ�ĳ��ȡ�
     * @param strEnd ������ַ�
     * @return ��ȡ��HtmlƬ�Ρ�
     */
    public static String interceptHtml(String shtml, int iLength, String strEnd) {
        StringBuffer result = new StringBuffer();
        // �ַ��ȱ�
        int n = 0;
        char charHtml;
        // �Ƿ���Html����
        boolean isCode = false;
        // �Ƿ���Html�����ַ�
        boolean isHtml = false;
        for (int i = 0; i < shtml.length(); i++) {
            // �ַ�����ֵ
            charHtml = shtml.charAt(i);
            if (charHtml == '<') {
                isCode = true;
            } else if (charHtml == '&') {
                isHtml = true;
            } else if (charHtml == '>' && isCode) {
                n = n - 1;
                isCode = false;
            } else if (charHtml == ';' && isHtml) {
                isHtml = false;
            }
            if (!isCode && !isHtml) {
                n = n + 1;
                if ((charHtml + "").getBytes().length > 1) {
                    n = n + 1;
                }
            }
            // ׷�ӵ�������(����String.valueOf(char[])����������ת��Ϊ�ַ���׷�ӵ�����)
            result.append(charHtml);
            if (n >= iLength) {
                break;
            }
        }
        // ��ӽ����ַ�(��ʶ)
        if (iLength < shtml.length()) {
            result.append(strEnd);
        } else {
            result.append("");
        }
        // ȡ���ȡ�ַ��е�Html��ǩ
        String splitStr = result.toString().replaceAll("(>)[^<>]*(<?)", "$1$2");
        // ȥ����Ҫ�����ǩ��html��ǩ
        splitStr = splitStr
                .replaceAll(
                        "</?(AREA|BASE|BASEFONT|BODY|BR|COL|COLGROUP|DD|DT|FRAME|HEAD|HR|HTML|IMG|INPUT|ISINDEX|LI|LINK|META|OPTION|PARAM|TBODY|TD|TFOOT|TH|THEAD|TR"
                                + "|area|base|basefont|body|br|col|colgroup|dd|dt|frame|head|hr|html|img|input|isindex|li|link|meta|option|param|tbody|td|tfoot|th|thead|tr)[^<>]*/?>",
                        "");
        // ȥ��ɶԵ�Html��ǩ
        for (int i = 0; i < (StringUtil.getNum(splitStr, "<") - StringUtil
                .getNum(splitStr, "</")); i++) {
            splitStr = splitStr.replaceAll("<([a-zA-Z]+)[^<>]*>(.*?)</\\1>",
                    "$2");
        }
        // ��������ʽȡ���ǩ
        Pattern pat = Pattern.compile("<([a-zA-Z]+)[^<>]*>");
        Matcher mat = pat.matcher(splitStr);

        List<String> endHtml = new ArrayList<String>();
        // find():���Բ������ģʽƥ����������е���һ��������
        while (mat.find()) {
            // group(int):��������ǰƥ������ڼ��ɸ��鲶�������������
            endHtml.add(mat.group(1));
        }
        // ��ȫ���ɶԵ�Html��ǩ
        for (int i = endHtml.size() - 1; i >= 0; i--) {
            result.append("</");
            result.append(endHtml.get(i));
            result.append(">");
        }
        return result.toString();
    }

    /**
     * һ����ٵļ����㷨��������ͨ���ַ��˷���Ϊ���棬�����������Ҫ��Ϣ�� ���淽��Ϊ{@link #decode(String)}��.
     * 
     * @param text Ҫ���ܵ��ַ�
     * @return ���ܹ���ַ�
     */
    public static String encode(String text) {
        return DESCrypto.encode(text);
    }

    /**
     * һ����ٵļ����㷨��������ͨ���ַ����򷽷�Ϊ{@link #encode(String)}��.
     * 
     * @param detext Ҫ���ܵ��ַ�
     * @return ���ؽ��ܹ���ַ�
     */
    public static String decode(String detext) {
        return DESCrypto.decode(detext);
    }

    /**
     * ��HTML������ͨ�ַ��ʽ������ַ���<tt>flag</tt>Ϊ<code>true</code>ʱ��
     * ���HTML��ʽ�����ַ���֮�������ͨ�ַ�.
     * 
     * @param html Ҫ��ʽ�����ַ�
     * @param flag �Ƿ�ת��ΪHTML��ʽ��
     * @return ��ʽ�����ַ�
     * @since 1.1
     */
    public static String formatPara(String html, boolean flag) {
        if (isNullOrEmpty(html))
            return EMPTY;
        String shtml = html;
        if (flag) {
            // shtml = shtml.replaceAll("&", "&amp;");
            shtml = shtml.replaceAll("<br[^>]*>", "\r\n");
            shtml = shtml.replaceAll(" ", "&nbsp;");
            shtml = shtml.replaceAll("\r\n", "\n");
            shtml = shtml.replaceAll("\n", "<br />");
        } else {
            shtml = shtml.replaceAll("<br[^>]*>", "\r\n");
            shtml = shtml.replaceAll("&nbsp;", " ");
            shtml = shtml.replaceAll("&amp;", "&");
        }
        return shtml;
    }

    /**
     * ��MD5�㷨�Ը��ժҪ�ַ���м��ܴ��?����ժҪ�ַ�Ϊ<code>null</code>�� �򷵻�{@link #EMPTY}�ַ�.
     * 
     * @param text Ҫ���ܵ�ժҪ�ַ�
     * @return ����MD5�㷨���ܹ��ժҪ�ַ�
     * @since 1.1
     */
    public static String md5(String text) {
        if (isNull(text))
            return EMPTY;
        byte[] b = text.getBytes();
        MessageDigest digest = null;
        try {
            digest = MessageDigest.getInstance("MD5");
            // �ø���ַ��ֽڸ���MD5�㷨��ժҪ��Ϣ
            digest.update(b);
            // ���MD5�Ĺ�ϣ����
            byte[] hashBytes = digest.digest();
            char[] chars = new char[hashBytes.length * 2];
            for (int i = 0, k = 0; i < hashBytes.length; i++) {
                chars[k++] = HEX_CHARS[hashBytes[i] >>> 4 & 0xf];
                chars[k++] = HEX_CHARS[hashBytes[i] & 0xf];
            }
            return new String(chars);
        } catch (NoSuchAlgorithmException nsae) {
            return text;
        }
    }

    /**
     * ʹ���ض��ļ����㷨���ܸ���ַ��ü���Ϊ�����档���ܺ���ַ���Զ�ǳ���Ϊ20λ���ַ�.
     * 
     * @param text Ҫ���ܵ�ժҪ�ַ�
     * @return �����ض��㷨���ܹ��ժҪ�ַ�
     * @since 1.1
     */
    public static String digest(String text) {
        String dedigest = md5(text);
        if (EMPTY.equals(dedigest))
            return EMPTY;
        StringBuffer sb = new StringBuffer();
        sb.append(dedigest.substring(2, 6));
        sb.append(dedigest.substring(8, 12));
        sb.append(dedigest.substring(14, 18));
        sb.append(dedigest.substring(20, 24));
        sb.append(dedigest.substring(26, 30));
        return sb.toString();
    }

    /**
     * ��������ܡ�.
     * 
     * @param password �����ַ�
     * @return Hash���ܺ�����롣
     * @since 1.1
     */
    public static String hashPassword(String password) {
        password = encryptImportant(password);
        return digest(password);
    }


    /**
     * �жϸ���ַ��Ƿ���url��ʽ
     * 
     * @param urlString ����ַ�
     * @return true or false
     */
    public static boolean isURL(String urlString) {
        String strRegexp = "^((https?|ftp|rtsp|mms|HTTPS?|FTP|RTSP|MMS)?://)?"
                + "(([0-9a-zA-Z_!~*'().&=+$%-]+: )?[0-9a-zA-Z_!~*'().&=+$%-]+@)?"
                + "(([0-9]{1,3}\\.){3}[0-9]{1,3}|([0-9a-zA-Z_!~*'()-]+\\.)*([0-9a-zA-Z][0-9a-zA-Z]{0,490})?[0-9a-zA-Z]\\.[a-zA-Z]{2,6})"
                + "(:[0-9]{1,4})?((/?)|(/[0-9a-zA-Z_!~*'().;?:@&=+$,%#-]+)+/?)|^/.*$";
        Pattern regex = Pattern.compile(strRegexp);
        Matcher matcher = regex.matcher(urlString);
        boolean isUrl = matcher.matches();
        if (isUrl) {
            return true;
        } else {
            return false;
        }
    }
    
    /**
     * ����HTML�����е����б�ǩ������������Ϣ
     * 
     * */
    public static String filterSpacialCharacter(String str) {
        if (null == str || "".equals(str.trim())) {
            return "";
        }
        return Pattern.compile("<(?:\"[^\"]*\"|'[^']*'|[^><])*>", Pattern.DOTALL).matcher(str).replaceAll("");
    }
    
    /**
     * ���תȫ��
     * @param input String.
     * @return ȫ���ַ�.
     */
    public static String toSBC(String input) {
        if (null == input) {
            return "";
        }
        char c[] = input.toCharArray();
        for (int i = 0; i < c.length; i++) {
            if (c[i] == ' ') {
                c[i] = '\u3000';
            } else if (c[i] == '.') {
                c[i] = '\u3002';
            } else if (c[i] < '\177') {
                c[i] = (char) (c[i] + 65248);
            }
        }
        return new String(c);
    }

    /**
     * ȫ��ת���
     * @param input String.
     * @return ����ַ�
     */
    public static String toDBC(String input) {
        if (null == input) {
            return "";
        }
        char c[] = input.toCharArray();
        for (int i = 0; i < c.length; i++) {
            if (c[i] == '\u3000') {
                c[i] = ' ';
            } else if (c[i] == '\u3002') {
                c[i] = '.';
            } else if (c[i] > '\uFF00' && c[i] < '\uFF5F') {
                c[i] = (char) (c[i] - 65248);

            }
        }
        return new String(c);
    }

    /**

    /**
     * ��Json������ΪJquery����ص���ʽ
     * 
     * @param jsoncallback �ص�����
     * @param json JSON����
     */
    public static String toJsonCallback(String jsoncallback, String json){
        if(jsoncallback!=null){
            return new StringBuffer().append(jsoncallback).append("(").append(json).append(")").toString();
        }else{
            return json;
        }
    }
    

//    /**  
//     * ����� {@code JSON} �ַ�ת����ָ�������Ͷ���<strong>�˷���ͨ����4ת����ͨ�� {@code JavaBean}  
//     * ����</strong>  
//     *   
//     * @param <T> Ҫת����Ŀ�����͡�  
//     * @param json ��� {@code JSON} �ַ�  
//     * @param clazz Ҫת����Ŀ���ࡣ  
//     * @return ��� {@code JSON} �ַ��ʾ��ָ�������Ͷ���  
//     */  
//    public static <T> T fromJson(String json, Class<T> clazz) {   
//    	return fromJson(json, clazz, null);   
//    }   
//
//    /**  
//     * ����� {@code JSON} �ַ�ת����ָ�������Ͷ���<strong>�˷���ͨ����4ת����ͨ�� {@code JavaBean}  
//     * ����</strong>  
//     *   
//     * @param <T> Ҫת����Ŀ�����͡�  
//     * @param json ��� {@code JSON} �ַ�  
//     * @param clazz Ҫת����Ŀ���ࡣ  
//     * @param datePattern ���ڸ�ʽģʽ��  
//     * @return ��� {@code JSON} �ַ��ʾ��ָ�������Ͷ���  
//     */  
//    public static <T> T fromJson(String json, Class<T> clazz, String datePattern) {   
//        if (isNullOrEmpty(json)) {   
//            return null;   
//        }   
//        GsonBuilder builder = new GsonBuilder();   
//        if (isNullOrEmpty(datePattern)) {   
//            datePattern = "yyyy-MM-dd HH:mm:ss";   
//        }   
//        Gson gson = builder.create();   
//        try {   
//            return gson.fromJson(json, clazz);   
//        } catch (Exception ex) { 
//        	ex.printStackTrace();
//            return null;   
//        }   
//    }   

    /**
     * ��DES�㷨��ָ�����ַ���м��ܴ��?�˷�����{@link #decryptNormal(String)} �������ʹ�á�.
     * 
     * @param text Ҫ���ܵ��ַ�
     * @return ������ܵ��ַ�
     * @since 1.0
     */
    public static String encryptNormal(String text) {
        //System.out.println("encryptNormal:"+text);
        return isNull(text) ? "" : DESCrypto.encrypt(text,
                DESCrypto.NORMAL_STRING);
    }

    /**
     * ��DES�㷨��ָ���������ַ���н��ܴ��?�˷�����{@link #encryptNormal(String)} �������ʹ�á�.
     * 
     * @param detext Ҫ���ܵ��ַ�
     * @return ������ܵ������ַ�
     * @since 1.0
     */
    public static String decryptNormal(String detext) {
        //System.out.println("decryptNormal:"+detext);
        if (isNullOrEmpty(detext)) {
            return EMPTY;
        } else {
            try {
                return DESCrypto.decrypt(detext, DESCrypto.NORMAL_STRING);
            } catch (Exception e) {
                return EMPTY;
            }
        }
    }

    /**
     * ��DES�㷨��ָ�����ַ�(ͨ�����������Ҫ���ַ�)���м��ܴ��?�˷�����{@link #decryptImportant(String)}
     * �������ʹ�á�.
     * 
     * @param text Ҫ���ܵ��ַ�
     * @return ������ܵ��ַ�
     * @since 1.0
     */
    public static String encryptImportant(String text) {
        //System.out.println("encryptImportant:"+text);
        return isNull(text) ? "" : DESCrypto.encrypt(text,
                DESCrypto.IMPORTANT_STRING);
    }

    /**
     * ��DES�㷨��ָ���������ַ�(ͨ�����������Ҫ���ַ�)���н��ܴ��?�˷�����{@link #encryptImportant(String)}
     * �������ʹ�á�.
     * 
     * @param detext Ҫ���ܵ��ַ�
     * @return ������ܵ������ַ�
     * @since 1.0
     */
    public static String decryptImportant(String detext) {
        //System.out.println("decryptImportant:"+detext);
        if (isNullOrEmpty(detext)) {
            return EMPTY;
        } else {
            try {
                return DESCrypto.decrypt(detext, DESCrypto.IMPORTANT_STRING);
            } catch (Exception e) {
                return EMPTY;
            }
        }
    }

    /**
     * split�����ķ�����ʵ�֡�.
     * 
     * @param strs Ҫ��ϵ��ַ�����
     * @param separator ÿ���ַ�֮��ĸ����
     * @return �������֮���<code>String</code>�ַ�
     */
    public static String reSplit(String[] strs, String separator) {
        StringBuffer sb = new StringBuffer();
        for (int i = 0; i < strs.length; i++) {
            sb.append(strs[i]).append(separator);
        }
        return sb.substring(0, sb.length() - separator.length());
    }

    /**
     * ��ʻ�����
     * 
     * @param locale ��action���õ�locale
     * @return ��4�����ʻ��Ķ���
     */
    public static TextProvider getTextProvider(final Locale locale) {
        LocaleProvider lp = new LocaleProvider() {
            public Locale getLocale() {
                return locale;
            }
        };
        return new TextProviderSupport(ResourceBundle.getBundle("giant",
                locale == null ? Locale.SIMPLIFIED_CHINESE : locale), lp);
    }
    
    /**
     * �ַ��ȡ
     *
     * @param text �ı���
     * @param length ��ȡ���ı����ȣ����ֽ�Ϊ��λ
     * 
     * @return String ��ȡ����ı���
     * 
     * @author wenjian
     */
    public static String cutString(String text, int length){
        return cutString(text, length, null, null);
    }
    /**
     * �ַ��ȡ
     *
     * @param text �ı���
     * @param length ��ȡ���ı����ȣ����ֽ�Ϊ��λ
     * @param mode (��ѡ����) ָ���Ƿ���ʡ�Բ��ݼӺ�׺��ֵ�У�auto(Ĭ��),true(����������Ϻ�׺),false(���������Ӻ�׺)
     * @param ellipsis (��ѡ����) ָ����ʡ�Բ��ݸ���ʲô��Ĭ��Ϊ"..."ʡ�Ժ�
     * 
     * @return String ��ȡ����ı���
     * 
     * @author wenjian
     */
    public static String cutString(String text, int length, String mode, String ... ellipsises){
        if(text==null || text.length()==0){
            return "";
        }
        String ellipsis;
        if(ellipsises==null || ellipsises.length==0 || ellipsises[0]==null){
            ellipsis = CUTSTR_DEFAULT_ELLIPSIS;
        }else{
            ellipsis = ellipsises[0];
        }
        int len = text.length();
        int i=0;
        for(int j=0;i<len && j<length;i++){
            char c = text.charAt(i);
            if(c>255){
                j+=2;
            }else{
                j++;
            }
        }
        text = text.substring(0, i);
        /* ����ʡ��ģʽ */
        if(mode==null || mode.equalsIgnoreCase(CUTSTR_MODE_AUTO)){
            if(i<len){
                text += ellipsis;
            }
        }else if(mode.equalsIgnoreCase(CUTSTR_MODE_TRUE)){
            text += ellipsis;
        }
        return text;
    }
    
    public static String generateToken(String uid) {
        Calendar instance = Calendar.getInstance();
        instance.set(Calendar.SECOND, 0);
        instance.set(Calendar.MILLISECOND, 0);
        return StringUtil.digest(uid.toUpperCase() + instance.getTime().getTime());
    }
    
    /** ʡ�Բ���: �Զ�������ı����ݳ���ȣ���ȡ����"..."�ţ����򣬲���"..." */
    public static final String CUTSTR_MODE_AUTO="auto";
    /** ʡ�Բ���: ������ô����ʡ��"..." */
    public static final String CUTSTR_MODE_TRUE="true";
    /** ʡ�Բ���: ������ô������ʡ��"..." */
    public static final String CUTSTR_MODE_FALSE="false";
    /** Ĭ��ʡ�Բ���׷�ӵ����� */
    public static final String CUTSTR_DEFAULT_ELLIPSIS="...";
	public static boolean empty(String o) {
		  return ((null == o) || (o.length() <= 0) || (o.trim().equals("")));  
	}
}
